22 research outputs found

    Fully Dynamic All-pairs Shortest Paths with Worst-case Update-time revisited

    No full text
    We revisit the classic problem of dynamically maintaining shortest paths between all pairs of nodes of a directed weighted graph. The allowed updates are insertions and deletions of nodes and their incident edges. We give worst-case guarantees on the time needed to process a single update (in contrast to related results, the update time is not amortized over a sequence of updates). Our main result is a simple randomized algorithm that for any parameter c>1c>1 has a worst-case update time of O(cn2+2/3log4/3n)O(cn^{2+2/3} \log^{4/3}{n}) and answers distance queries correctly with probability 11/nc1-1/n^c, against an adaptive online adversary if the graph contains no negative cycle. The best deterministic algorithm is by Thorup [STOC 2005] with a worst-case update time of O~(n2+3/4)\tilde O(n^{2+3/4}) and assumes non-negative weights. This is the first improvement for this problem for more than a decade. Conceptually, our algorithm shows that randomization along with a more direct approach can provide better bounds

    Near-Optimal Approximate Shortest Paths and Transshipment in Distributed and Streaming Models

    Get PDF
    We present a method for solving the shortest transshipment problem-also known as uncapacitated minimum cost flow-up to a multiplicative error of 1 + ϵ in undirected graphs with non-negative integer edge weights using a tailored gradient descent algorithm. Our gradient descent algorithm takes ϵ-3 polylog n iterations, and in each iteration it needs to solve an instance of the transshipment problem up to a multiplicative error of polylog n, where n is the number of nodes. In particular, this allows us to perform a single iteration by computing a solution on a sparse spanner of logarithmic stretch. Using a careful white-box analysis, we can further extend the method to finding approximate solutions for the single-source shortest paths (SSSP) problem. As a consequence, we improve prior work by obtaining the following results: 1. Broadcast CONGEST model: (1+")-approximate SSSP using Õ((√ n+D) · ϵ-O(1)) rounds, 1 where D is the (hop) diameter of the network. 2. Broadcast congested clique model: (1+ϵ)-approximate shortest transshipment and SSSP using Õ (ϵ-O(1)) rounds. 3. Multipass streaming model: (1+ϵ)-approximate shortest transshipment and SSSP using Õ (n) space and Õ(ϵ-O(1)) passes. The previously fastest SSSP algorithms for these models leverage sparse hop sets. We bypass the hop set construction; computing a spanner is sufficient with our method. The above bounds assume non-negative integer edge weights that are polynomially bounded in n; for general nonnegative weights, running times scale with the logarithm of the maximum ratio between non-zero weights. In case of asymmetric costs for traversing an edge in opposite directions, running times scale with the maximum ratio between the costs of both directions over all edges

    On Fully Dynamic Graph Sparsifiers

    No full text
    We initiate the study of dynamic algorithms for graph sparsification problems and obtain fully dynamic algorithms, allowing both edge insertions and edge deletions, that take polylogarithmic time after each update in the graph. Our three main results are as follows. First, we give a fully dynamic algorithm for maintaining a (1±ϵ) (1 \pm \epsilon) -spectral sparsifier with amortized update time poly(logn,ϵ1)poly(\log{n}, \epsilon^{-1}). Second, we give a fully dynamic algorithm for maintaining a (1±ϵ) (1 \pm \epsilon) -cut sparsifier with \emph{worst-case} update time poly(logn,ϵ1)poly(\log{n}, \epsilon^{-1}). Both sparsifiers have size npoly(logn,ϵ1) n \cdot poly(\log{n}, \epsilon^{-1}). Third, we apply our dynamic sparsifier algorithm to obtain a fully dynamic algorithm for maintaining a (1+ϵ)(1 + \epsilon)-approximation to the value of the maximum flow in an unweighted, undirected, bipartite graph with amortized update time poly(logn,ϵ1)poly(\log{n}, \epsilon^{-1})

    Fully Dynamic All-Pairs Shortest Paths with Worst-Case Update-Time Revisited

    No full text

    Approximate Undirected Transshipment and Shortest Paths via Gradient Descent

    No full text
    We present a method for solving the transshipment problem - also known as uncapacitated minimum cost flow - up to a multiplicative error of 1+ϵ1 + \epsilon in undirected graphs with polynomially bounded integer edge weights using a tailored gradient descent algorithm. An important special case of the transshipment problem is the single-source shortest paths (SSSP) problem. Our gradient descent algorithm takes O(ϵ3polylogn)O(\epsilon^{-3} \mathrm{polylog} n) iterations and in each iteration it needs to solve a variant of the transshipment problem up to a multiplicative error of polylogn\mathrm{polylog} n. In particular, this allows us to perform a single iteration by computing a solution on a sparse spanner of logarithmic stretch. As a consequence, we improve prior work by obtaining the following results: (1) RAM model: (1+ϵ)(1+\epsilon)-approximate transshipment in O~(ϵ3(m+n1+o(1)))\tilde{O}(\epsilon^{-3}(m + n^{1 + o(1)})) computational steps (leveraging a recent O(m1+o(1))O(m^{1+o(1)})-step O(1)O(1)-approximation due to Sherman [2016]). (2) Multipass Streaming model: (1+ϵ)(1 + \epsilon)-approximate transshipment and SSSP using O~(n)\tilde{O}(n) space and O~(ϵO(1))\tilde{O}(\epsilon^{-O(1)}) passes. (3) Broadcast Congested Clique model: (1+ϵ)(1 + \epsilon)-approximate transshipment and SSSP using O~(ϵO(1))\tilde{O}(\epsilon^{-O(1)}) rounds. (4) Broadcast Congest model: (1+ϵ)(1 + \epsilon)-approximate SSSP using O~(ϵO(1)(n+D))\tilde{O}(\epsilon^{-O(1)}(\sqrt{n} + D)) rounds, where D D is the (hop) diameter of the network. The previous fastest algorithms for the last three models above leverage sparse hop sets. We bypass the hop set computation; using a spanner is sufficient in our method. The above bounds assume non-negative integer edge weights that are polynomially bounded in nn; for general non-negative weights, running times scale with the logarithm of the maximum ratio between non-zero weights

    On Fully Dynamic Graph Sparsifiers

    No full text
    We initiate the study of dynamic algorithms for graph sparsification problems and obtain fully dynamic algorithms, allowing both edge insertions and edge deletions, that take polylogarithmic time after each update in the graph. Our three main results are as follows. First, we give a fully dynamic algorithm for maintaining a (1±ϵ) (1 \pm \epsilon) -spectral sparsifier with amortized update time poly(logn,ϵ1)poly(\log{n}, \epsilon^{-1}). Second, we give a fully dynamic algorithm for maintaining a (1±ϵ) (1 \pm \epsilon) -cut sparsifier with \emph{worst-case} update time poly(logn,ϵ1)poly(\log{n}, \epsilon^{-1}). Both sparsifiers have size npoly(logn,ϵ1) n \cdot poly(\log{n}, \epsilon^{-1}). Third, we apply our dynamic sparsifier algorithm to obtain a fully dynamic algorithm for maintaining a (1+ϵ)(1 + \epsilon)-approximation to the value of the maximum flow in an unweighted, undirected, bipartite graph with amortized update time poly(logn,ϵ1)poly(\log{n}, \epsilon^{-1})

    Decremental data structures for connectivity and dominators in directed graphs

    Get PDF
    We introduce a new dynamic data structure for maintaining the strongly connected components (SCCs) of a directed graph (digraph) under edge deletions, so as to answer a rich repertoire of connectivity queries. Our main technical contribution is a decremental data structure that supports sensitivity queries of the form "are u and v strongly connected in the graph G\w?", for any triple of vertices u, v,w, while G undergoes deletions of edges. Our data structure processes a sequence of edge deletions in a digraph with n vertices in O(mnlog n) total time and O(n2 log n) space, where m is the number of edges before any deletion, and answers the above queries in constant time. We can leverage our data structure to obtain decremental data structures for many more types of queries within the same time and space complexity. For instance for edgerelated queries, such as testing whether two query vertices u and v are strongly connected in G \ e, for some query edge e. As another important application of our decremental data structure, we provide the first nontrivial algorithm for maintaining the dominator tree of a flow graph under edge deletions. We present an algorithm that processes a sequence of edge deletions in a flow graph in O(mnlog n) total time and O(n2 log n) space. For reducible flow graphs we provide an O(mn)-time and O(m+n)-space algorithm. We give a conditional lower bound that provides evidence that these running times may be tight up to subpolynomial factors
    corecore